package com.fit.utils.se;

import java.io.IOException;
import java.io.UnsupportedEncodingException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 编码工具(对文本的编码和解码)
 * byte[]和十六进制 的编码与解码
 * BASE64编码解码
 * 
 * @author hcl
 *
 */
@SuppressWarnings("restriction")
public class EncryptUtil {

	private static Logger log = LoggerFactory.getLogger(EncryptUtil.class);
	
	/**
	 * 默认为UTF-8的编码
	 */
	private final static String DEFAULT_CHARACTER_ENCODING = "UTF-8";
	
	/**
	 * base64编码对象
	 */
	
	private static sun.misc.BASE64Encoder base64Encoder = new sun.misc.BASE64Encoder();
	/**
	 * base64解码对象
	 */
	private static sun.misc.BASE64Decoder base64Decoder = new sun.misc.BASE64Decoder();
	
	
	// //////////////////////////////////////////////////////////
    // byte[]和十六进制 的编码与解码
    // //////////////////////////////////////////////////////////
	

	/**
	 * 将byte数组转换为十六进制字符串(1一个byte将会转换为两个字符)
	 * 
	 * @param b 数组
	 * @return
	 * @author hcl
	 */
	public static String byte2hex(byte[] b) {
		String stmp = null;
		StringBuilder sb = new StringBuilder();
		for (int n = 0; n < b.length; n++) {
			stmp = (Integer.toHexString(b[n] & 0XFF));
			sb.append(stmp.length() == 1 ? "0" + stmp : stmp);
		}
		return sb.toString().toUpperCase();
	}
	
	
	/**
	 * 将十六进制字符串转换为byte数组(两个字符将会转换为1个byte,所以传入的长度必须是偶数)
	 * 
	 * @param hex 十六进制字符串
	 * @return
	 * @author hcl
	 */
	public static byte[] hex2byte(String hexStr){
		byte[] b = new byte[hexStr.length()/2];
		int j=0;
		for(int i=0; i<hexStr.length(); i+=2){
			char c1 = hexStr.charAt(i);
			char c2 = hexStr.charAt(i+1);
			String s = null;
			s = (c1 == '0') ? "" + c2 : c1 + "" + c2;
			b[j++] = (byte)(Integer.parseInt(s, 16) & 0XFF);
		}
		return b;
	}
	
	
	
    // //////////////////////////////////////////////////////////
    // BASE64编码解码
    // //////////////////////////////////////////////////////////
	
	/**
	 * 将传入的byte进行base64编码 
	 * 数组变为一个可见的字符串，并返回 
	 * @param b
	 * @return 返回编码的字符串
	 */
	public static String base64Encoder(byte[] b) {
		return EncryptUtil.base64Encoder.encode(b).replace("\r", "").replace("\n", "");
	}
	
	/**
	 * 将传入的字符串进行base64编码 
	 * 为一个可见的字符串，并返回 
	 * @param str
	 * @param encoding
	 * @return 返回编码的字符串
	 * @throws UnsupportedEncodingException 
	 */
	public static String base64Encoder(String str,String encoding) {
		try {
			return EncryptUtil.base64Encoder(str.getBytes(encoding));
		} catch (UnsupportedEncodingException e) {
			log.error("base64编码异常",e);
			return null;
		}
	}
	
	/**
	 * 将传入的字符串进行base64编码 
	 * 为一个可见的字符串，并返回 
	 * @param str
	 * @return 返回编码的字符串
	 */
	public static String base64Encoder(String str) {
		return base64Encoder(str, DEFAULT_CHARACTER_ENCODING);
	}
	
	
	

	/**
	 * 将一个字符串进行base64解码
	 * @param str
	 * @return	返回解码后的byte数组
	 * @throws IOException 
	 */
	public static byte[] base64DecoderToByte(String str) {
		byte[] result = null;
		try {
			result = EncryptUtil.base64Decoder.decodeBuffer(str);
		} catch (IOException e) {
			log.error("base64解码异常", e);
		}
		return result;
	}
	
	
	/**
	 * 将一个字符串进行base64解码
	 * @param str
	 * @param encoding
	 * @return 解码后的字符串
	 * @throws IOException 
	 * @throws UnsupportedEncodingException 
	 */
	public static String base64Decoder(String str,String encoding) {
		String result = null;
		try {
			result = new String(EncryptUtil.base64DecoderToByte(str),encoding);
		} catch (Exception e) {
			log.error("base6解码异常", e);
		}
		return result;
	}
	
	/**
	 * 将一个字符串进行base64解码
	 * @param str
	 * @return 解码后的字符串
	 * @throws IOException 
	 */
	public static String base64Decoder(String str) {
		return EncryptUtil.base64Decoder(str, DEFAULT_CHARACTER_ENCODING);
	}
	
}
